import axios, { AxiosError } from 'axios';

// API基础URL
const BASE_URL = process.env.API_BASE_URL || 'http://localhost:3912';
const API_URL = `${BASE_URL}/api/v1`;

// 颜色输出
const colors = {
  green: '\x1b[32m',
  red: '\x1b[31m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  reset: '\x1b[0m'
};

// 测试结果统计
let passedTests = 0;
let failedTests = 0;

/**
 * 打印测试结果
 */
function printResult(testName: string, passed: boolean, message?: string) {
  if (passed) {
    console.log(`${colors.green}✓${colors.reset} ${testName}`);
    if (message) console.log(`  ${colors.blue}${message}${colors.reset}`);
    passedTests++;
  } else {
    console.log(`${colors.red}✗${colors.reset} ${testName}`);
    if (message) console.log(`  ${colors.red}${message}${colors.reset}`);
    failedTests++;
  }
}

/**
 * 延迟函数
 */
function delay(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

/**
 * 主测试函数
 */
async function runTests() {
  console.log('\n' + '='.repeat(50));
  console.log('认证API测试');
  console.log('='.repeat(50) + '\n');

  let adminToken = '';

  // ========== 测试1: 管理员登录（成功） ==========
  try {
    console.log(`${colors.yellow}测试1: 管理员登录（成功）${colors.reset}`);
    const response = await axios.post(`${API_URL}/auth/admin/login`, {
      username: 'admin',
      password: 'password123'
    });

    if (response.data.success && response.data.data.token) {
      adminToken = response.data.data.token;
      printResult('管理员登录成功', true, `Token: ${adminToken.substring(0, 20)}...`);
      printResult('响应包含用户信息', true, `用户名: ${response.data.data.admin.username}, 角色: ${response.data.data.admin.role}`);
    } else {
      printResult('管理员登录成功', false, '响应格式不正确');
    }
  } catch (error: any) {
    printResult('管理员登录成功', false, error.message);
  }

  await delay(500);

  // ========== 测试2: 管理员登录（失败 - 密码错误） ==========
  try {
    console.log(`\n${colors.yellow}测试2: 管理员登录（失败 - 密码错误）${colors.reset}`);
    await axios.post(`${API_URL}/auth/admin/login`, {
      username: 'admin',
      password: 'wrongpassword'
    });
    printResult('管理员登录失败（密码错误）', false, '应该返回401错误');
  } catch (error) {
    const axiosError = error as AxiosError<any>;
    if (axiosError.response?.status === 401) {
      printResult('管理员登录失败（密码错误）', true, `返回401: ${axiosError.response.data.message}`);
    } else {
      printResult('管理员登录失败（密码错误）', false, `期望401，实际: ${axiosError.response?.status}`);
    }
  }

  await delay(500);

  // ========== 测试3: 管理员登录（失败 - 用户不存在） ==========
  try {
    console.log(`\n${colors.yellow}测试3: 管理员登录（失败 - 用户不存在）${colors.reset}`);
    await axios.post(`${API_URL}/auth/admin/login`, {
      username: 'nonexistent',
      password: 'password123'
    });
    printResult('管理员登录失败（用户不存在）', false, '应该返回401错误');
  } catch (error) {
    const axiosError = error as AxiosError<any>;
    if (axiosError.response?.status === 401) {
      printResult('管理员登录失败（用户不存在）', true, `返回401: ${axiosError.response.data.message}`);
    } else {
      printResult('管理员登录失败（用户不存在）', false, `期望401，实际: ${axiosError.response?.status}`);
    }
  }

  await delay(500);

  // ========== 测试4: 获取当前用户信息（带Token） ==========
  if (adminToken) {
    try {
      console.log(`\n${colors.yellow}测试4: 获取当前用户信息（带Token）${colors.reset}`);
      const response = await axios.get(`${API_URL}/auth/me`, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

      if (response.data.success && response.data.data.id) {
        printResult('获取用户信息成功', true, `用户ID: ${response.data.data.id}, 用户名: ${response.data.data.username}`);
      } else {
        printResult('获取用户信息成功', false, '响应格式不正确');
      }
    } catch (error: any) {
      printResult('获取用户信息成功', false, error.message);
    }

    await delay(500);
  }

  // ========== 测试5: 获取当前用户信息（无Token） ==========
  try {
    console.log(`\n${colors.yellow}测试5: 获取当前用户信息（无Token）${colors.reset}`);
    await axios.get(`${API_URL}/auth/me`);
    printResult('获取用户信息失败（无Token）', false, '应该返回401错误');
  } catch (error) {
    const axiosError = error as AxiosError<any>;
    if (axiosError.response?.status === 401) {
      printResult('获取用户信息失败（无Token）', true, `返回401: ${axiosError.response.data.message}`);
    } else {
      printResult('获取用户信息失败（无Token）', false, `期望401，实际: ${axiosError.response?.status}`);
    }
  }

  await delay(500);

  // ========== 测试6: 获取当前用户信息（无效Token） ==========
  try {
    console.log(`\n${colors.yellow}测试6: 获取当前用户信息（无效Token）${colors.reset}`);
    await axios.get(`${API_URL}/auth/me`, {
      headers: {
        'Authorization': 'Bearer invalid_token_here'
      }
    });
    printResult('获取用户信息失败（无效Token）', false, '应该返回401错误');
  } catch (error) {
    const axiosError = error as AxiosError<any>;
    if (axiosError.response?.status === 401) {
      printResult('获取用户信息失败（无效Token）', true, `返回401: ${axiosError.response.data.message}`);
    } else {
      printResult('获取用户信息失败（无效Token）', false, `期望401，实际: ${axiosError.response?.status}`);
    }
  }

  // ========== 测试总结 ==========
  console.log('\n' + '='.repeat(50));
  console.log('测试总结');
  console.log('='.repeat(50));
  console.log(`${colors.green}通过: ${passedTests}${colors.reset}`);
  console.log(`${colors.red}失败: ${failedTests}${colors.reset}`);
  console.log(`总计: ${passedTests + failedTests}\n`);

  if (failedTests === 0) {
    console.log(`${colors.green}✓ 所有测试通过！${colors.reset}\n`);
    process.exit(0);
  } else {
    console.log(`${colors.red}✗ 部分测试失败${colors.reset}\n`);
    process.exit(1);
  }
}

// 检查服务器是否运行
async function checkServer() {
  try {
    await axios.get(`${BASE_URL}/health`, { timeout: 3912 });
    return true;
  } catch (error) {
    return false;
  }
}

// 主入口
(async () => {
  console.log(`\n检查服务器连接: ${BASE_URL}`);
  const serverRunning = await checkServer();

  if (!serverRunning) {
    console.log(`${colors.red}✗ 无法连接到服务器${colors.reset}`);
    console.log(`请先启动服务器: npm run dev\n`);
    process.exit(1);
  }

  console.log(`${colors.green}✓ 服务器连接成功${colors.reset}\n`);

  await runTests();
})();
